package cn.wzx.controller;

import cn.wzx.entity.MyUser;
import cn.wzx.entity.OrdInfo;
import cn.wzx.entity.Order;
import cn.wzx.entity.OrderLine;
import cn.wzx.respJson.RespJson;
import cn.wzx.respJson.Token;
import cn.wzx.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.*;

import java.beans.PropertyEditorSupport;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@CrossOrigin // 允许跨域访问
@Controller
@RequestMapping("/api/fore/ord")
public class OrdController {
    @Autowired
    OrderService orderService;

    // 日期格式化
    @InitBinder
    public void initBinder(final WebDataBinder webdataBinder){
        webdataBinder.registerCustomEditor(java.util.Date.class, new PropertyEditorSupport(){
            @Override
            public void setAsText(String text) throws IllegalArgumentException{
                if (text.indexOf("-")>0){
                    if (text.indexOf("")<1){
                        text = text + " 00:00:00";
                    }
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd" +
                            "HH:mm:ss");
                    try {
                        Date d = sdf.parse(text);
                        setValue(d);
                    }catch (Exception e){
                        System.out.println("书本日期错误...." + text );
                        setValue(new Date()); //毫秒
                    }
                }else {
                    setValue(new Date(Long.valueOf(text))); //毫秒
                }
            }
        });
    }

    //根据订单号获取该订单明细及书本信息, 简化前端开发
    @ResponseBody
    @RequestMapping("/findItemInfoByOrdid/{ordid}")
    public Map<String,Object> findItemInfoByOrdid(@PathVariable("ordid") Integer ordid){
        List<Map<String, Object>> lst = orderService.findItemInfoByOrdid(ordid);
        System.out.println("lst===========" + lst);
        return RespJson.pack(200, "", lst);
    }

    // 添加地址
    @ResponseBody
    @RequestMapping("/addAddr")
    public Map<String, Object> addAddr(@RequestBody Order order) {
        orderService.addAddr(order);
        return RespJson.pack(200, "添加地址成功", "");
    }

    // 付款功能
    @ResponseBody
    @RequestMapping("/addPay")
    public Map<String, Object> save(@RequestBody Order order) {
        System.out.println("order==============" + order);
        // 付款状态为1表示已付款
        order.setIspay(1);
        order.setTpay(new Date());
        orderService.addPay(order);
        // 根据订单ID 找到该订单并返回给前端
        Order ord = orderService.findOrderById(order.getOrdid());
        return RespJson.pack(200, "付款成功", ord);
    }

    @ResponseBody
    @RequestMapping("/findInfoByOrdid/{ordid}")
    // 查找该登录用户下某一个订单号
    public Map<String, Object> findInfoByOrdid(@PathVariable("ordid") Integer ordid) {
        // 获取到登录后的token，从中获取到登录者的信息，从而获取到用户ID
        MyUser user = (MyUser)Token.getUser();
        int uid = user.getId();
        if (uid < 0) return RespJson.pack(401,"请重新登录",null);
        //根据用户 ID 和 订单 ID 找到该订单的订单明细以及订单明细里的书本信息，订单和订单明细是一对多的关系，订单明细和书本信息是一对一的关系
        OrdInfo ordInfo = orderService.findInfoByOrdid(uid, ordid);
        return RespJson.pack(200, "", ordInfo);
    }

    // 查找该登录用户的所有订单头信息
    @ResponseBody
    @RequestMapping("/findOrdLines")
    public Map<String,Object> findOrdLines(Integer ispay,Date tstart,Date tend){
        Map<String ,Object> map = new HashMap<>();
        // 动态条件查询，有哪些信息传入就只通过传入的信息进行查询
        if (ispay != null) map.put("ispay",ispay);
        if (tstart != null) map.put("tstart",tstart);
        if (tend != null) map.put("tend",tend);
        // 获取到登录后的token，从中获取到登录者的信息，从而获取到用户ID
        MyUser user = (MyUser)Token.getUser();
        int uid = user.getId();
        if (uid < 0) return RespJson.pack(401,"Token过期,请重新登录",null);
        map.put("uid",uid);
        try {
            //动态条件查询，模糊查询，有值传入就查询，没有值就跳过，查询到用户所有订单头信息包括用户信息
            List<OrderLine> lst = orderService.findOrdLines(map);
            return RespJson.pack(200,"",lst);
        }catch (Exception e){
            e.printStackTrace();
            return RespJson.pack(500,"查询失败",null);
        }
    }

    // 查找该登录用户的所有订单头信息有分页功能
    @ResponseBody
    @RequestMapping("/findOrdLineByPage/{start}/{num}")
    public Map<String ,Object> findOrdLineByPage(@PathVariable("start") Integer start,@PathVariable("num") Integer num,Integer ispay,Date tstart,Date tend){
        System.out.println("ispay=============" + ispay);
        System.out.println("tstart=============" + tstart);
        System.out.println("tend=============" + tend);
        // 第一个map用来接收数据调用sql查询
        Map<String ,Object> map = new HashMap<>();
        // 动态条件查询，有哪些信息传入就只通过传入的信息进行查询
        // 有数据传入就添加到map中
        if (ispay != null) map.put("ispay",ispay);
        if (tstart != null) map.put("tstart",tstart);
        if (tend != null) map.put("tend",tend);
        // 获取到登录后的token，从中获取到登录者的信息，从而获取到用户ID
        MyUser user = (MyUser)Token.getUser();
        int uid = user.getId();
        // 没有用户登录信息
        if (uid < 0) return RespJson.pack(401,"Token过期,请重新登录",null);
        map.put("uid",uid);
        map.put("start",start*num);
        map.put("num",num);
        // 计算总页数
        int count = orderService.count(map);
        // 第二个map用来接收查询后的数据返回给前端
        Map<String ,Object> map2 = new HashMap<>();
        map2.put("total",count);
        try {
            //动态条件查询，模糊查询，有值传入就查询，没有值就跳过，查询到用户所有订单头信息包括用户信息
            List<OrderLine> lst = orderService.findOrdLines(map);
            map2.put("orders",lst);
            return RespJson.pack(200,"",map2);
        }catch (Exception e){
            e.printStackTrace();
            return RespJson.pack(500,"查询失败",null);
        }
    }


}
